package com.example.course.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.course.bean.Classes;
import com.example.course.bean.Student;
import com.example.course.converter.ClassesConverter;
import com.example.course.converter.StudentConverter;
import com.example.course.dto.ClassesDTO;
import com.example.course.dto.ClassesQueryDTO;
import com.example.course.mapper.ClassesMapper;
import com.example.course.service.ClassesService;
import com.example.course.service.StudentService;
import com.example.course.vo.ClassesVO;
import com.example.course.vo.StudentVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * @author Jasmine-drs
 * @description 针对表【classes(班级表)】的数据库操作Service实现
 * @createDate 2025-04-22 15:36:40
 */
@Slf4j
@Service
public class ClassesServiceImpl extends ServiceImpl<ClassesMapper, Classes>
		implements ClassesService {

	private final StudentService studentService;
    private final ClassesConverter classesConverter;
    private final StudentConverter studentConverter;

    public ClassesServiceImpl(@Lazy StudentService studentService, ClassesConverter classesConverter, StudentConverter studentConverter) {
        this.studentService = studentService;
        this.classesConverter = classesConverter;
        this.studentConverter = studentConverter;
    }

	/**
	 * 获取班级列表，支持按条件查询和分页
	 *
	 * @param queryDTO 查询条件
	 * @return 班级分页列表
	 */
	@Override
	public Page<ClassesVO> getClassesList(ClassesQueryDTO queryDTO) {
		log.info("执行获取班级列表：{}", queryDTO);

        // 构建查询条件
        LambdaQueryWrapper<Classes> queryWrapper = new LambdaQueryWrapper<>();
        if (!StringUtils.isEmpty(queryDTO.getName())) {
            queryWrapper.like(Classes::getName, queryDTO.getName());
        }

        // 如果指定了班主任ID，查询该教师作为班主任的班级
        if (queryDTO.getTeacherId() != null) {
            queryWrapper.eq(Classes::getTeacherId, queryDTO.getTeacherId());
        }

        // 分页查询
        Page<Classes> page = new Page<>(queryDTO.getCurrent(), queryDTO.getSize());
        Page<Classes> classesPage = page(page, queryWrapper);

        // 转换为VO
        Page<ClassesVO> voPage = new Page<>();
        voPage.setCurrent(classesPage.getCurrent());
        voPage.setSize(classesPage.getSize());
        voPage.setTotal(classesPage.getTotal());
        voPage.setRecords(classesConverter.toVOList(classesPage.getRecords()));

        return voPage;
    }

    /**
     * 添加班级，包含班级名重复检查
     *
     * @param classesDTO 班级信息
     * @return 添加后的班级信息
     * @throws IllegalArgumentException 当班级名已存在时抛出
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ClassesVO addClass(ClassesDTO classesDTO) {
        log.info("执行添加班级：{}", classesDTO);

        // 检查班级名是否已存在
        LambdaQueryWrapper<Classes> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Classes::getName, classesDTO.getName());
        if (count(queryWrapper) > 0) {
            log.warn("班级名已存在：{}", classesDTO.getName());
            throw new IllegalArgumentException("班级名已存在，请更换班级名");
        }

        // 将DTO转换为实体
        Classes classes = classesConverter.toEntity(classesDTO);

        // 保存班级信息
        boolean result = save(classes);
        if (!result) {
            log.error("添加班级失败：{}", classesDTO);
            throw new RuntimeException("添加班级失败");
        }

        // 返回VO
        return classesConverter.toVO(classes);
    }

    /**
     * 删除班级（物理删除）
     *
     * @param id 班级ID
     * @return 删除结果，true表示成功，false表示失败
     * @throws IllegalArgumentException 当班级不存在或班级中有学生时抛出
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteClass(Integer id) {
        log.info("执行删除班级，ID：{}", id);

        // 检查班级是否存在
        Classes classes = getById(id);
        if (classes == null) {
            log.warn("班级不存在，ID：{}", id);
            throw new IllegalArgumentException("班级不存在");
        }

        // 检查班级中是否有学生
        LambdaQueryWrapper<Student> studentWrapper = new LambdaQueryWrapper<>();
        studentWrapper.eq(Student::getClassesId, id);
        long studentCount = studentService.count(studentWrapper);
        if (studentCount > 0) {
            log.warn("班级中存在学生，无法删除，ID：{}", id);
            throw new IllegalArgumentException("班级中存在学生，请先将学生移出班级后再删除");
        }

        // 删除班级（物理删除）
        return removeById(id);
    }

    /**
     * 根据ID获取班级信息
     *
     * @param id 班级ID
     * @return 班级信息
     * @throws IllegalArgumentException 当班级不存在时抛出
     */
    @Override
    public ClassesVO getClassById(Integer id) {
        log.info("执行获取班级详情，ID：{}", id);

        // 获取班级信息
        Classes classes = getById(id);
        if (classes == null) {
            log.warn("班级不存在，ID：{}", id);
            throw new IllegalArgumentException("班级不存在");
        }

        // 转换为VO
        return classesConverter.toVO(classes);
    }

    /**
     * 获取班级内的学生列表
     *
     * @param id 班级ID
     * @return 学生列表
     * @throws IllegalArgumentException 当班级不存在时抛出
     */
    @Override
    public List<StudentVO> getStudentsByClassId(Integer id) {
        log.info("执行获取班级学生列表，班级ID：{}", id);

        // 检查班级是否存在
        Classes classes = getById(id);
        if (classes == null) {
            log.warn("班级不存在，ID：{}", id);
            throw new IllegalArgumentException("班级不存在");
        }

        // 查询班级内的学生
        LambdaQueryWrapper<Student> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Student::getClassesId, id);
        List<Student> students = studentService.list(queryWrapper);

        // 转换为VO
        return studentConverter.toVOList(students);
    }
}




